{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T09:01:34.581937Z",
     "start_time": "2018-11-27T09:01:34.564089Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import requests\n",
    "import csv\n",
    "from bs4 import BeautifulSoup\n",
    "from datetime import datetime, timedelta\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.tsa import stattools\n",
    "from statsmodels.tsa.seasonal import seasonal_decompose\n",
    "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n",
    "from statsmodels.tsa.stattools import acf, pacf\n",
    "import os\n",
    "from pandas import Series\n",
    "from pandas import concat\n",
    "from pandas import read_csv\n",
    "from pandas import datetime\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "# import tensorflow as tf\n",
    "# config = tf.ConfigProto()\n",
    "# config.gpu_options.allow_growth = True\n",
    "# config.gpu_options.per_process_gpu_memory_fraction = 0.4\n",
    "# sess = tf.Session(config=config)\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras.layers import LSTM, RNN, GRU, SimpleRNN, Dropout\n",
    "from math import sqrt\n",
    "from matplotlib import pyplot\n",
    "from numpy import array\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "os.environ['CUDA_VISIBLE_DEVICES']=''\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (15, 6)\n",
    "\n",
    "from numpy.random import seed\n",
    "seed(1)\n",
    "from tensorflow import set_random_seed\n",
    "set_random_seed(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T14:00:57.492435Z",
     "start_time": "2018-11-27T14:00:53.745372Z"
    }
   },
   "outputs": [],
   "source": [
    "data = pd.read_csv('lstm_data.csv', header=None, names=['datetime', 'load'], index_col=[0], parse_dates=[0], infer_datetime_format=True)\n",
    "df = pd.DataFrame(columns=['time'] + list(map(str, range(int(data.shape[0] / 288)))))\n",
    "for idx, time in enumerate(sorted(set(data.index.time))):\n",
    "    df.loc[idx] = [time.strftime(format='%H:%M:%S')] + list(data.at_time(time)['load'].values)\n",
    "df.index = df['time']\n",
    "df = df.drop('time', 1)\n",
    "dt_df = df.diff(1, axis=1)\n",
    "dt_df = dt_df.dropna(axis=1)\n",
    "scaler = MinMaxScaler(feature_range=(-1, 1))\n",
    "scaler = scaler.fit(dt_df.values.reshape(-1, 1))\n",
    "dt_df = scaler.transform(dt_df)  # dt_df is now a numpy array\n",
    "split_idx = int(len(dt_df) * 0.8)\n",
    "train, val = dt_df[:split_idx, :], dt_df[split_idx:, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T14:00:58.264408Z",
     "start_time": "2018-11-27T14:00:58.257882Z"
    }
   },
   "outputs": [],
   "source": [
    "def prepare_data(data, nlags):\n",
    "    '''prepares data for LSTM model, x=last nlags values, y=(nlags+1)'th value'''\n",
    "    data_x, data_y = [], []\n",
    "    for i in range(data.shape[0]):\n",
    "        for j in range(0, data.shape[1]-nlags):\n",
    "            data_x.append(data[i, j:j+nlags])\n",
    "            data_y.append(data[i, j+nlags])\n",
    "    data_x = np.array(data_x)\n",
    "    data_y = np.array(data_y).reshape(-1, 1)\n",
    "    return data_x, data_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T17:46:05.376493Z",
     "start_time": "2018-11-27T17:46:05.319328Z"
    }
   },
   "outputs": [],
   "source": [
    "nlags = 10\n",
    "train_x, train_y = prepare_data(train, nlags)\n",
    "val_x, val_y = prepare_data(val, nlags)\n",
    "train_x = train_x.reshape(train_x.shape[0], 1, nlags)\n",
    "val_x = val_x.reshape(val_x.shape[0], 1, nlags)\n",
    "df_last_nlags_plus_one = df.loc[:, df.columns[-nlags-1:]]  # slice last nlags+1 days from df, will be used in prediction of yesterday's data\n",
    "dt_df_last_nlags = df_last_nlags_plus_one.diff(1, axis=1).dropna(axis=1)  #taking last 21 days, differencing and dropping the nan value\n",
    "dt_df_last_nlags = scaler.transform(dt_df_last_nlags)  # df is now a numpy array\n",
    "X = dt_df_last_nlags.reshape(dt_df_last_nlags.shape[0], 1, nlags)  # nlags=20\n",
    "load = np.load('25nov.npy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T17:46:37.263995Z",
     "start_time": "2018-11-27T17:46:37.098761Z"
    }
   },
   "outputs": [],
   "source": [
    "del model\n",
    "batch_size = 1\n",
    "model = Sequential()\n",
    "model.add(SimpleRNN(1, batch_input_shape=(batch_size, train_x.shape[1], train_x.shape[2])))\n",
    "model.add(Dense(train_y.shape[1]))\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "es = EarlyStopping(monitor='val_loss',\n",
    "                              min_delta=0,\n",
    "                              patience=3,\n",
    "                              verbose=0, mode='auto')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T17:49:17.223381Z",
     "start_time": "2018-11-27T17:46:38.727052Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/20\n",
      "11270/11270 [==============================] - 33s 3ms/step - loss: 0.0383 - val_loss: 0.0200\n",
      "Epoch 2/20\n",
      "11270/11270 [==============================] - 31s 3ms/step - loss: 0.0268 - val_loss: 0.0199\n",
      "Epoch 3/20\n",
      "11270/11270 [==============================] - 31s 3ms/step - loss: 0.0266 - val_loss: 0.0203\n",
      "Epoch 4/20\n",
      "11270/11270 [==============================] - 31s 3ms/step - loss: 0.0265 - val_loss: 0.0204\n",
      "Epoch 5/20\n",
      "11270/11270 [==============================] - 32s 3ms/step - loss: 0.0263 - val_loss: 0.0200\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(train_x, train_y, epochs=20, batch_size=batch_size, verbose=1, validation_data=(val_x, val_y), shuffle=True, callbacks=[es])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T16:39:07.200210Z",
     "start_time": "2018-11-27T16:29:53.982658Z"
    },
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 27s 3ms/step - loss: 0.0315 - val_loss: 0.0190\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 27s 3ms/step - loss: 0.0311 - val_loss: 0.0191\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 28s 3ms/step - loss: 0.0307 - val_loss: 0.0190\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 27s 3ms/step - loss: 0.0303 - val_loss: 0.0191\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 27s 3ms/step - loss: 0.0301 - val_loss: 0.0189\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 25s 2ms/step - loss: 0.0298 - val_loss: 0.0185\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 26s 3ms/step - loss: 0.0294 - val_loss: 0.0179\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 27s 3ms/step - loss: 0.0289 - val_loss: 0.0175\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 27s 3ms/step - loss: 0.0284 - val_loss: 0.0174\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 29s 3ms/step - loss: 0.0280 - val_loss: 0.0173\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 29s 3ms/step - loss: 0.0278 - val_loss: 0.0173\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 29s 3ms/step - loss: 0.0275 - val_loss: 0.0173\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 32s 3ms/step - loss: 0.0274 - val_loss: 0.0173\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 30s 3ms/step - loss: 0.0273 - val_loss: 0.0173\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 29s 3ms/step - loss: 0.0272 - val_loss: 0.0173\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 25s 3ms/step - loss: 0.0272 - val_loss: 0.0174\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 25s 2ms/step - loss: 0.0271 - val_loss: 0.0174\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 27s 3ms/step - loss: 0.0271 - val_loss: 0.0175\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 28s 3ms/step - loss: 0.0271 - val_loss: 0.0175\n",
      "Train on 10120 samples, validate on 2552 samples\n",
      "Epoch 1/1\n",
      "10120/10120 [==============================] - 28s 3ms/step - loss: 0.0271 - val_loss: 0.0175\n"
     ]
    }
   ],
   "source": [
    "# fit network\n",
    "early_stopping_counter = 0\n",
    "last_loss = np.inf\n",
    "for i in range(20):\n",
    "    history = model.fit(train_x, train_y, epochs=1, batch_size=batch_size, verbose=1, validation_data=(val_x, val_y), shuffle=False)\n",
    "    model.reset_states()\n",
    "    val_loss = history.history['val_loss'][0]\n",
    "    if val_loss > last_loss:\n",
    "        early_stopping_counter += 1\n",
    "    else:    \n",
    "        early_stopping_counter = 0\n",
    "    last_loss = val_loss\n",
    "    if early_stopping_counter == 3:\n",
    "#         break\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T17:49:20.997139Z",
     "start_time": "2018-11-27T17:49:17.227406Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2842/2842 [==============================] - 3s 1ms/step\n"
     ]
    }
   ],
   "source": [
    "val_y_pred = model.predict(val_x, batch_size=batch_size, verbose=1)\n",
    "inverted_val_y = scaler.inverse_transform(val_y)\n",
    "inverted_val_y_pred = scaler.inverse_transform(val_y_pred)\n",
    "Y = model.predict(X, batch_size=batch_size)  # predict for today's values\n",
    "inv_Y = scaler.inverse_transform(Y)  # invert to detrended values' scale\n",
    "rescaled_Y = [x+y for x, y in zip(inv_Y[:, 0], df.iloc[:, -1])]  # last day's values added to inv_Y to get it to original scale\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T17:49:21.008337Z",
     "start_time": "2018-11-27T17:49:21.001187Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "166.6308253179372 190.08200151118467\n"
     ]
    }
   ],
   "source": [
    "val_RMSE = np.sqrt(np.sum(np.square(np.array(inverted_val_y_pred) - np.array(inverted_val_y))) / len(inverted_val_y)) \n",
    "RMSE = np.sqrt(np.sum(np.square(np.array(rescaled_Y) - load)) / len(load)) \n",
    "print(val_RMSE, RMSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T17:49:21.522175Z",
     "start_time": "2018-11-27T17:49:21.011589Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f36b01b0400>"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(load)\n",
    "plt.plot(rescaled_Y)\n",
    "plt.legend(['load', 'pred'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-26T14:50:25.042244Z",
     "start_time": "2018-11-26T14:50:25.034708Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-26T18:38:21.891195Z",
     "start_time": "2018-11-26T18:38:18.452738Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[NbConvertApp] Converting notebook LSTM-v2.ipynb to script\n",
      "[NbConvertApp] Writing 9421 bytes to LSTM-v2.py\n"
     ]
    }
   ],
   "source": [
    "# !jupyter nbconvert --to script LSTM-v2.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-26T18:38:21.901581Z",
     "start_time": "2018-11-26T18:38:21.895444Z"
    }
   },
   "outputs": [],
   "source": [
    "# ## get today's load\n",
    "\n",
    "# def get_load_data(date):\n",
    "#     load=[]\n",
    "#     url = 'http://www.delhisldc.org/Loaddata.aspx?mode='\n",
    "#     print('Scraping ' + date, end=' ')\n",
    "#     resp = requests.get(url + date) # send a get request to the url, get response\n",
    "#     soup = BeautifulSoup(resp.text, 'lxml') # Yummy HTML soup\n",
    "#     table = soup.find('table', {'id':'ContentPlaceHolder3_DGGridAv'}) # get the table from html\n",
    "#     trs = table.findAll('tr') # extract all rows of the table\n",
    "#     if len(trs[1:])==288: # no need to create csv file, if there's no data\n",
    "#         with open('monthdata.csv', 'a') as f:  #'a' makes sure the values are appended at the end of the already existing file\n",
    "            \n",
    "#             for tr in trs[1:]:\n",
    "#                 time, delhi = tr.findChildren('font')[:2]\n",
    "#                 load.append(delhi.text)\n",
    "#     if len(trs[1:]) != 288:\n",
    "#         print('Some of the load values are missing..')\n",
    "#     else:\n",
    "#         print('Done')\n",
    "#     return load\n",
    "\n",
    "# yesterday = datetime.today() - timedelta(1)\n",
    "# yesterday = yesterday.strftime('%d/%m/%Y')\n",
    "# load = get_load_data(yesterday)\n",
    "# load = [float(x) for x in load]\n",
    "# np.save('25nov.npy', load)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "TF",
   "language": "python",
   "name": "tf"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
